1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.collect;
18
19 import static com.google.common.collect.Iterables.getOnlyElement;
20 import static com.google.common.collect.Iterables.unmodifiableIterable;
21 import static com.google.common.collect.Sets.newHashSet;
22 import static java.lang.reflect.Proxy.newProxyInstance;
23 import static java.util.Arrays.asList;
24
25 import com.google.common.annotations.GwtCompatible;
26 import com.google.common.annotations.GwtIncompatible;
27 import com.google.common.collect.testing.Helpers;
28 import com.google.common.collect.testing.ListTestSuiteBuilder;
29 import com.google.common.collect.testing.MinimalCollection;
30 import com.google.common.collect.testing.MinimalIterable;
31 import com.google.common.collect.testing.features.CollectionFeature;
32 import com.google.common.collect.testing.features.CollectionSize;
33 import com.google.common.collect.testing.google.ListGenerators.BuilderAddAllListGenerator;
34 import com.google.common.collect.testing.google.ListGenerators.BuilderReversedListGenerator;
35 import com.google.common.collect.testing.google.ListGenerators.ImmutableListHeadSubListGenerator;
36 import com.google.common.collect.testing.google.ListGenerators.ImmutableListMiddleSubListGenerator;
37 import com.google.common.collect.testing.google.ListGenerators.ImmutableListOfGenerator;
38 import com.google.common.collect.testing.google.ListGenerators.ImmutableListTailSubListGenerator;
39 import com.google.common.collect.testing.google.ListGenerators.UnhashableElementsImmutableListGenerator;
40 import com.google.common.collect.testing.testers.ListHashCodeTester;
41 import com.google.common.testing.NullPointerTester;
42 import com.google.common.testing.SerializableTester;
43
44 import junit.framework.Test;
45 import junit.framework.TestCase;
46 import junit.framework.TestSuite;
47
48 import java.lang.reflect.InvocationHandler;
49 import java.lang.reflect.InvocationTargetException;
50 import java.lang.reflect.Method;
51 import java.util.Arrays;
52 import java.util.Collection;
53 import java.util.Collections;
54 import java.util.Iterator;
55 import java.util.List;
56 import java.util.Set;
57 import java.util.concurrent.CopyOnWriteArrayList;
58
59
60
61
62
63
64
65
66 @GwtCompatible(emulated = true)
67 public class ImmutableListTest extends TestCase {
68
69 @GwtIncompatible("suite")
70 public static Test suite() {
71 TestSuite suite = new TestSuite();
72 suite.addTest(ListTestSuiteBuilder.using(new ImmutableListOfGenerator())
73 .named("ImmutableList")
74 .withFeatures(CollectionSize.ANY,
75 CollectionFeature.SERIALIZABLE,
76 CollectionFeature.ALLOWS_NULL_QUERIES)
77 .createTestSuite());
78 suite.addTest(ListTestSuiteBuilder.using(new BuilderAddAllListGenerator())
79 .named("ImmutableList, built with Builder.add")
80 .withFeatures(CollectionSize.ANY,
81 CollectionFeature.SERIALIZABLE,
82 CollectionFeature.ALLOWS_NULL_QUERIES)
83 .createTestSuite());
84 suite.addTest(ListTestSuiteBuilder.using(new BuilderAddAllListGenerator())
85 .named("ImmutableList, built with Builder.addAll")
86 .withFeatures(CollectionSize.ANY,
87 CollectionFeature.SERIALIZABLE,
88 CollectionFeature.ALLOWS_NULL_QUERIES)
89 .createTestSuite());
90 suite.addTest(ListTestSuiteBuilder.using(new BuilderReversedListGenerator())
91 .named("ImmutableList, reversed")
92 .withFeatures(CollectionSize.ANY,
93 CollectionFeature.SERIALIZABLE,
94 CollectionFeature.ALLOWS_NULL_QUERIES)
95 .createTestSuite());
96 suite.addTest(ListTestSuiteBuilder.using(
97 new ImmutableListHeadSubListGenerator())
98 .named("ImmutableList, head subList")
99 .withFeatures(CollectionSize.ANY,
100 CollectionFeature.SERIALIZABLE,
101 CollectionFeature.ALLOWS_NULL_QUERIES)
102 .createTestSuite());
103 suite.addTest(ListTestSuiteBuilder.using(
104 new ImmutableListTailSubListGenerator())
105 .named("ImmutableList, tail subList")
106 .withFeatures(CollectionSize.ANY,
107 CollectionFeature.SERIALIZABLE,
108 CollectionFeature.ALLOWS_NULL_QUERIES)
109 .createTestSuite());
110 suite.addTest(ListTestSuiteBuilder.using(
111 new ImmutableListMiddleSubListGenerator())
112 .named("ImmutableList, middle subList")
113 .withFeatures(CollectionSize.ANY,
114 CollectionFeature.SERIALIZABLE,
115 CollectionFeature.ALLOWS_NULL_QUERIES)
116 .createTestSuite());
117 suite.addTest(ListTestSuiteBuilder.using(
118 new UnhashableElementsImmutableListGenerator())
119 .suppressing(ListHashCodeTester.getHashCodeMethod())
120 .named("ImmutableList, unhashable values")
121 .withFeatures(CollectionSize.ANY,
122 CollectionFeature.ALLOWS_NULL_QUERIES)
123 .createTestSuite());
124 return suite;
125 }
126
127 public static class CreationTests extends TestCase {
128 public void testCreation_noArgs() {
129 List<String> list = ImmutableList.of();
130 assertEquals(Collections.emptyList(), list);
131 }
132
133 public void testCreation_oneElement() {
134 List<String> list = ImmutableList.of("a");
135 assertEquals(Collections.singletonList("a"), list);
136 }
137
138 public void testCreation_twoElements() {
139 List<String> list = ImmutableList.of("a", "b");
140 assertEquals(Lists.newArrayList("a", "b"), list);
141 }
142
143 public void testCreation_threeElements() {
144 List<String> list = ImmutableList.of("a", "b", "c");
145 assertEquals(Lists.newArrayList("a", "b", "c"), list);
146 }
147
148 public void testCreation_fourElements() {
149 List<String> list = ImmutableList.of("a", "b", "c", "d");
150 assertEquals(Lists.newArrayList("a", "b", "c", "d"), list);
151 }
152
153 public void testCreation_fiveElements() {
154 List<String> list = ImmutableList.of("a", "b", "c", "d", "e");
155 assertEquals(Lists.newArrayList("a", "b", "c", "d", "e"), list);
156 }
157
158 public void testCreation_sixElements() {
159 List<String> list = ImmutableList.of("a", "b", "c", "d", "e", "f");
160 assertEquals(Lists.newArrayList("a", "b", "c", "d", "e", "f"), list);
161 }
162
163 public void testCreation_sevenElements() {
164 List<String> list = ImmutableList.of("a", "b", "c", "d", "e", "f", "g");
165 assertEquals(Lists.newArrayList("a", "b", "c", "d", "e", "f", "g"), list);
166 }
167
168 public void testCreation_eightElements() {
169 List<String> list = ImmutableList.of(
170 "a", "b", "c", "d", "e", "f", "g", "h");
171 assertEquals(Lists.newArrayList(
172 "a", "b", "c", "d", "e", "f", "g", "h"), list);
173 }
174
175 public void testCreation_nineElements() {
176 List<String> list = ImmutableList.of(
177 "a", "b", "c", "d", "e", "f", "g", "h", "i");
178 assertEquals(Lists.newArrayList(
179 "a", "b", "c", "d", "e", "f", "g", "h", "i"), list);
180 }
181
182 public void testCreation_tenElements() {
183 List<String> list = ImmutableList.of(
184 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j");
185 assertEquals(Lists.newArrayList(
186 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j"), list);
187 }
188
189 public void testCreation_elevenElements() {
190 List<String> list = ImmutableList.of(
191 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k");
192 assertEquals(Lists.newArrayList(
193 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"), list);
194 }
195
196
197
198 public void testCreation_twelveElements() {
199 List<String> list = ImmutableList.of(
200 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l");
201 assertEquals(Lists.newArrayList(
202 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"), list);
203 }
204
205 public void testCreation_thirteenElements() {
206 List<String> list = ImmutableList.of(
207 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m");
208 assertEquals(Lists.newArrayList(
209 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"),
210 list);
211 }
212
213 public void testCreation_fourteenElements() {
214 List<String> list = ImmutableList.of(
215 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n");
216 assertEquals(Lists.newArrayList(
217 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"),
218 list);
219 }
220
221 public void testCreation_singletonNull() {
222 try {
223 ImmutableList.of((String) null);
224 fail();
225 } catch (NullPointerException expected) {
226 }
227 }
228
229 public void testCreation_withNull() {
230 try {
231 ImmutableList.of("a", null, "b");
232 fail();
233 } catch (NullPointerException expected) {
234 }
235 }
236
237 public void testCreation_generic() {
238 List<String> a = ImmutableList.of("a");
239
240 ImmutableList.of(a, a);
241 }
242
243 public void testCreation_arrayOfArray() {
244 String[] array = new String[] { "a" };
245 List<String[]> list = ImmutableList.<String[]>of(array);
246 assertEquals(Collections.singletonList(array), list);
247 }
248
249 public void testCopyOf_emptyArray() {
250 String[] array = new String[0];
251 List<String> list = ImmutableList.copyOf(array);
252 assertEquals(Collections.emptyList(), list);
253 }
254
255 public void testCopyOf_arrayOfOneElement() {
256 String[] array = new String[] { "a" };
257 List<String> list = ImmutableList.copyOf(array);
258 assertEquals(Collections.singletonList("a"), list);
259 }
260
261 public void testCopyOf_nullArray() {
262 try {
263 ImmutableList.copyOf((String[]) null);
264 fail();
265 } catch (NullPointerException expected) {
266 }
267 }
268
269 public void testCopyOf_arrayContainingOnlyNull() {
270 String[] array = new String[] { null };
271 try {
272 ImmutableList.copyOf(array);
273 fail();
274 } catch (NullPointerException expected) {
275 }
276 }
277
278 public void testCopyOf_collection_empty() {
279
280 Collection<String> c = MinimalCollection.<String>of();
281 List<String> list = ImmutableList.copyOf(c);
282 assertEquals(Collections.emptyList(), list);
283 }
284
285 public void testCopyOf_collection_oneElement() {
286 Collection<String> c = MinimalCollection.of("a");
287 List<String> list = ImmutableList.copyOf(c);
288 assertEquals(Collections.singletonList("a"), list);
289 }
290
291 public void testCopyOf_collection_general() {
292 Collection<String> c = MinimalCollection.of("a", "b", "a");
293 List<String> list = ImmutableList.copyOf(c);
294 assertEquals(asList("a", "b", "a"), list);
295 List<String> mutableList = asList("a", "b");
296 list = ImmutableList.copyOf(mutableList);
297 mutableList.set(0, "c");
298 assertEquals(asList("a", "b"), list);
299 }
300
301 public void testCopyOf_collectionContainingNull() {
302 Collection<String> c = MinimalCollection.of("a", null, "b");
303 try {
304 ImmutableList.copyOf(c);
305 fail();
306 } catch (NullPointerException expected) {
307 }
308 }
309
310 public void testCopyOf_iterator_empty() {
311 Iterator<String> iterator = Iterators.emptyIterator();
312 List<String> list = ImmutableList.copyOf(iterator);
313 assertEquals(Collections.emptyList(), list);
314 }
315
316 public void testCopyOf_iterator_oneElement() {
317 Iterator<String> iterator = Iterators.singletonIterator("a");
318 List<String> list = ImmutableList.copyOf(iterator);
319 assertEquals(Collections.singletonList("a"), list);
320 }
321
322 public void testCopyOf_iterator_general() {
323 Iterator<String> iterator = asList("a", "b", "a").iterator();
324 List<String> list = ImmutableList.copyOf(iterator);
325 assertEquals(asList("a", "b", "a"), list);
326 }
327
328 public void testCopyOf_iteratorContainingNull() {
329 Iterator<String> iterator = asList("a", null, "b").iterator();
330 try {
331 ImmutableList.copyOf(iterator);
332 fail();
333 } catch (NullPointerException expected) {
334 }
335 }
336
337 public void testCopyOf_iteratorNull() {
338 try {
339 ImmutableList.copyOf((Iterator<String>) null);
340 fail();
341 } catch (NullPointerException expected) {
342 }
343 }
344
345 public void testCopyOf_concurrentlyMutating() {
346 List<String> sample = Lists.newArrayList("a", "b", "c");
347 for (int delta : new int[] {-1, 0, 1}) {
348 for (int i = 0; i < sample.size(); i++) {
349 Collection<String> misleading =
350 Helpers.misleadingSizeCollection(delta);
351 List<String> expected = sample.subList(0, i);
352 misleading.addAll(expected);
353 assertEquals(expected, ImmutableList.copyOf(misleading));
354 assertEquals(expected,
355 ImmutableList.copyOf((Iterable<String>) misleading));
356 }
357 }
358 }
359
360 private static class CountingIterable implements Iterable<String> {
361 int count = 0;
362 @Override
363 public Iterator<String> iterator() {
364 count++;
365 return asList("a", "b", "a").iterator();
366 }
367 }
368
369 public void testCopyOf_plainIterable() {
370 CountingIterable iterable = new CountingIterable();
371 List<String> list = ImmutableList.copyOf(iterable);
372 assertEquals(asList("a", "b", "a"), list);
373 }
374
375 public void testCopyOf_plainIterable_iteratesOnce() {
376 CountingIterable iterable = new CountingIterable();
377 ImmutableList.copyOf(iterable);
378 assertEquals(1, iterable.count);
379 }
380
381 public void testCopyOf_shortcut_empty() {
382 Collection<String> c = ImmutableList.of();
383 assertSame(c, ImmutableList.copyOf(c));
384 }
385
386 public void testCopyOf_shortcut_singleton() {
387 Collection<String> c = ImmutableList.of("a");
388 assertSame(c, ImmutableList.copyOf(c));
389 }
390
391 public void testCopyOf_shortcut_immutableList() {
392 Collection<String> c = ImmutableList.of("a", "b", "c");
393 assertSame(c, ImmutableList.copyOf(c));
394 }
395
396 public void testBuilderAddArrayHandlesNulls() {
397 String[] elements = {"a", null, "b"};
398 ImmutableList.Builder<String> builder = ImmutableList.builder();
399 try {
400 builder.add(elements);
401 fail ("Expected NullPointerException");
402 } catch (NullPointerException expected) {
403 }
404 ImmutableList<String> result = builder.build();
405
406
407
408
409
410 if (result.isEmpty()) {
411 return;
412 }
413 assertTrue(ImmutableList.of("a").equals(result));
414 assertEquals(1, result.size());
415 }
416
417 public void testBuilderAddCollectionHandlesNulls() {
418 List<String> elements = Arrays.asList("a", null, "b");
419 ImmutableList.Builder<String> builder = ImmutableList.builder();
420 try {
421 builder.addAll(elements);
422 fail ("Expected NullPointerException");
423 } catch (NullPointerException expected) {
424 }
425 ImmutableList<String> result = builder.build();
426 assertEquals(ImmutableList.of("a"), result);
427 assertEquals(1, result.size());
428 }
429 }
430
431 @GwtIncompatible("reflection")
432 public static class ConcurrentTests extends TestCase {
433 enum WrapWithIterable { WRAP, NO_WRAP }
434
435 private static void runConcurrentlyMutatedTest(
436 Collection<Integer> initialContents,
437 Iterable<ListFrobber> actionsToPerformConcurrently,
438 WrapWithIterable wrap) {
439 ConcurrentlyMutatedList<Integer> concurrentlyMutatedList =
440 newConcurrentlyMutatedList(
441 initialContents, actionsToPerformConcurrently);
442
443 Iterable<Integer> iterableToCopy = wrap == WrapWithIterable.WRAP
444 ? unmodifiableIterable(concurrentlyMutatedList)
445 : concurrentlyMutatedList;
446
447 ImmutableList<Integer> copyOfIterable =
448 ImmutableList.copyOf(iterableToCopy);
449
450 assertTrue(concurrentlyMutatedList.getAllStates()
451 .contains(copyOfIterable));
452
453
454 assertEquals(copyOfIterable.size() == 1,
455 copyOfIterable instanceof SingletonImmutableList);
456 }
457
458 private static void runConcurrentlyMutatedTest(WrapWithIterable wrap) {
459
460
461
462
463 runConcurrentlyMutatedTest(
464 elements(),
465 ops(add(1), add(2)),
466 wrap);
467
468 runConcurrentlyMutatedTest(
469 elements(),
470 ops(add(1), nop()),
471 wrap);
472
473 runConcurrentlyMutatedTest(
474 elements(),
475 ops(add(1), remove()),
476 wrap);
477
478 runConcurrentlyMutatedTest(
479 elements(),
480 ops(nop(), add(1)),
481 wrap);
482
483 runConcurrentlyMutatedTest(
484 elements(1),
485 ops(remove(), nop()),
486 wrap);
487
488 runConcurrentlyMutatedTest(
489 elements(1),
490 ops(remove(), add(2)),
491 wrap);
492
493 runConcurrentlyMutatedTest(
494 elements(1, 2),
495 ops(remove(), remove()),
496 wrap);
497
498 runConcurrentlyMutatedTest(
499 elements(1, 2),
500 ops(remove(), nop()),
501 wrap);
502
503 runConcurrentlyMutatedTest(
504 elements(1, 2),
505 ops(remove(), add(3)),
506 wrap);
507
508 runConcurrentlyMutatedTest(
509 elements(1, 2),
510 ops(nop(), remove()),
511 wrap);
512
513 runConcurrentlyMutatedTest(
514 elements(1, 2, 3),
515 ops(remove(), remove()),
516 wrap);
517 }
518
519 private static ImmutableList<Integer> elements(Integer... elements) {
520 return ImmutableList.copyOf(elements);
521 }
522
523 private static ImmutableList<ListFrobber> ops(ListFrobber... elements) {
524 return ImmutableList.copyOf(elements);
525 }
526
527 public void testCopyOf_concurrentlyMutatedList() {
528 runConcurrentlyMutatedTest(WrapWithIterable.NO_WRAP);
529 }
530
531 public void testCopyOf_concurrentlyMutatedIterable() {
532 runConcurrentlyMutatedTest(WrapWithIterable.WRAP);
533 }
534
535
536 interface ListFrobber {
537 void perform(List<Integer> list);
538 }
539
540 static ListFrobber add(final int element) {
541 return new ListFrobber() {
542 @Override
543 public void perform(List<Integer> list) {
544 list.add(0, element);
545 }
546 };
547 }
548
549 static ListFrobber remove() {
550 return new ListFrobber() {
551 @Override
552 public void perform(List<Integer> list) {
553 list.remove(0);
554 }
555 };
556 }
557
558 static ListFrobber nop() {
559 return new ListFrobber() {
560 @Override
561 public void perform(List<Integer> list) {
562 }
563 };
564 }
565
566
567
568
569
570 interface ConcurrentlyMutatedList<E> extends List<E> {
571
572
573
574
575
576 Set<List<E>> getAllStates();
577 }
578
579
580
581
582
583
584 private static ConcurrentlyMutatedList<Integer> newConcurrentlyMutatedList(
585 final Collection<Integer> initialContents,
586 final Iterable<ListFrobber> actionsToPerformConcurrently) {
587 InvocationHandler invocationHandler = new InvocationHandler() {
588 final CopyOnWriteArrayList<Integer> delegate =
589 new CopyOnWriteArrayList<Integer>(initialContents);
590
591 final Method getAllStatesMethod = getOnlyElement(asList(
592 ConcurrentlyMutatedList.class.getDeclaredMethods()));
593
594 final Iterator<ListFrobber> remainingActions =
595 actionsToPerformConcurrently.iterator();
596
597 final Set<List<Integer>> allStates = newHashSet();
598
599 @Override
600 public Object invoke(Object proxy, Method method,
601 Object[] args) throws Throwable {
602 return method.equals(getAllStatesMethod)
603 ? getAllStates()
604 : invokeListMethod(method, args);
605 }
606
607 private Set<List<Integer>> getAllStates() {
608 return allStates;
609 }
610
611 private Object invokeListMethod(Method method, Object[] args)
612 throws Throwable {
613 try {
614 Object returnValue = method.invoke(delegate, args);
615 mutateDelegate();
616 return returnValue;
617 } catch (InvocationTargetException e) {
618 throw e.getCause();
619 } catch (IllegalAccessException e) {
620 throw new AssertionError(e);
621 }
622 }
623
624 private void mutateDelegate() {
625 allStates.add(ImmutableList.copyOf(delegate));
626 remainingActions.next().perform(delegate);
627 allStates.add(ImmutableList.copyOf(delegate));
628 }
629 };
630
631 @SuppressWarnings("unchecked")
632 ConcurrentlyMutatedList<Integer> list =
633 (ConcurrentlyMutatedList<Integer>) newProxyInstance(
634 ImmutableListTest.CreationTests.class.getClassLoader(),
635 new Class[] {ConcurrentlyMutatedList.class}, invocationHandler);
636 return list;
637 }
638 }
639
640 public static class BasicTests extends TestCase {
641
642 @GwtIncompatible("NullPointerTester")
643 public void testNullPointers() {
644 NullPointerTester tester = new NullPointerTester();
645 tester.testAllPublicStaticMethods(ImmutableList.class);
646 tester.testAllPublicInstanceMethods(ImmutableList.of(1, 2, 3));
647 }
648
649 @GwtIncompatible("SerializableTester")
650 public void testSerialization_empty() {
651 Collection<String> c = ImmutableList.of();
652 assertSame(c, SerializableTester.reserialize(c));
653 }
654
655 @GwtIncompatible("SerializableTester")
656 public void testSerialization_singleton() {
657 Collection<String> c = ImmutableList.of("a");
658 SerializableTester.reserializeAndAssert(c);
659 }
660
661 @GwtIncompatible("SerializableTester")
662 public void testSerialization_multiple() {
663 Collection<String> c = ImmutableList.of("a", "b", "c");
664 SerializableTester.reserializeAndAssert(c);
665 }
666
667 public void testEquals_immutableList() {
668 Collection<String> c = ImmutableList.of("a", "b", "c");
669 assertTrue(c.equals(ImmutableList.of("a", "b", "c")));
670 assertFalse(c.equals(ImmutableList.of("a", "c", "b")));
671 assertFalse(c.equals(ImmutableList.of("a", "b")));
672 assertFalse(c.equals(ImmutableList.of("a", "b", "c", "d")));
673 }
674
675 public void testBuilderAdd() {
676 ImmutableList<String> list = new ImmutableList.Builder<String>()
677 .add("a")
678 .add("b")
679 .add("a")
680 .add("c")
681 .build();
682 assertEquals(asList("a", "b", "a", "c"), list);
683 }
684
685 public void testBuilderAdd_varargs() {
686 ImmutableList<String> list = new ImmutableList.Builder<String>()
687 .add("a", "b", "a", "c")
688 .build();
689 assertEquals(asList("a", "b", "a", "c"), list);
690 }
691
692 public void testBuilderAddAll_iterable() {
693 List<String> a = asList("a", "b");
694 List<String> b = asList("c", "d");
695 ImmutableList<String> list = new ImmutableList.Builder<String>()
696 .addAll(a)
697 .addAll(b)
698 .build();
699 assertEquals(asList( "a", "b", "c", "d"), list);
700 b.set(0, "f");
701 assertEquals(asList( "a", "b", "c", "d"), list);
702 }
703
704 public void testBuilderAddAll_iterator() {
705 List<String> a = asList("a", "b");
706 List<String> b = asList("c", "d");
707 ImmutableList<String> list = new ImmutableList.Builder<String>()
708 .addAll(a.iterator())
709 .addAll(b.iterator())
710 .build();
711 assertEquals(asList( "a", "b", "c", "d"), list);
712 b.set(0, "f");
713 assertEquals(asList( "a", "b", "c", "d"), list);
714 }
715
716 public void testComplexBuilder() {
717 List<Integer> colorElem = asList(0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF);
718 ImmutableList.Builder<Integer> webSafeColorsBuilder
719 = ImmutableList.builder();
720 for (Integer red : colorElem) {
721 for (Integer green : colorElem) {
722 for (Integer blue : colorElem) {
723 webSafeColorsBuilder.add((red << 16) + (green << 8) + blue);
724 }
725 }
726 }
727 ImmutableList<Integer> webSafeColors = webSafeColorsBuilder.build();
728 assertEquals(216, webSafeColors.size());
729 Integer[] webSafeColorArray =
730 webSafeColors.toArray(new Integer[webSafeColors.size()]);
731 assertEquals(0x000000, (int) webSafeColorArray[0]);
732 assertEquals(0x000033, (int) webSafeColorArray[1]);
733 assertEquals(0x000066, (int) webSafeColorArray[2]);
734 assertEquals(0x003300, (int) webSafeColorArray[6]);
735 assertEquals(0x330000, (int) webSafeColorArray[36]);
736 assertEquals(0x000066, (int) webSafeColors.get(2));
737 assertEquals(0x003300, (int) webSafeColors.get(6));
738 ImmutableList<Integer> addedColor
739 = webSafeColorsBuilder.add(0x00BFFF).build();
740 assertEquals("Modifying the builder should not have changed any already"
741 + " built sets", 216, webSafeColors.size());
742 assertEquals("the new array should be one bigger than webSafeColors",
743 217, addedColor.size());
744 Integer[] appendColorArray =
745 addedColor.toArray(new Integer[addedColor.size()]);
746 assertEquals(0x00BFFF, (int) appendColorArray[216]);
747 }
748
749 public void testBuilderAddHandlesNullsCorrectly() {
750 ImmutableList.Builder<String> builder = ImmutableList.builder();
751 try {
752 builder.add((String) null);
753 fail("expected NullPointerException");
754 } catch (NullPointerException expected) {
755 }
756
757 try {
758 builder.add((String[]) null);
759 fail("expected NullPointerException");
760 } catch (NullPointerException expected) {
761 }
762
763 try {
764 builder.add("a", null, "b");
765 fail("expected NullPointerException");
766 } catch (NullPointerException expected) {
767 }
768 }
769
770 public void testBuilderAddAllHandlesNullsCorrectly() {
771 ImmutableList.Builder<String> builder = ImmutableList.builder();
772 try {
773 builder.addAll((Iterable<String>) null);
774 fail("expected NullPointerException");
775 } catch (NullPointerException expected) {
776 }
777
778 try {
779 builder.addAll((Iterator<String>) null);
780 fail("expected NullPointerException");
781 } catch (NullPointerException expected) {
782 }
783
784 builder = ImmutableList.builder();
785 List<String> listWithNulls = asList("a", null, "b");
786 try {
787 builder.addAll(listWithNulls);
788 fail("expected NullPointerException");
789 } catch (NullPointerException expected) {
790 }
791
792 builder = ImmutableList.builder();
793 Iterator<String> iteratorWithNulls = asList("a", null, "b").iterator();
794 try {
795 builder.addAll(iteratorWithNulls);
796 fail("expected NullPointerException");
797 } catch (NullPointerException expected) {
798 }
799
800 Iterable<String> iterableWithNulls = MinimalIterable.of("a", null, "b");
801 try {
802 builder.addAll(iterableWithNulls);
803 fail("expected NullPointerException");
804 } catch (NullPointerException expected) {
805 }
806 }
807
808 public void testAsList() {
809 ImmutableList<String> list = ImmutableList.of("a", "b");
810 assertSame(list, list.asList());
811 }
812 }
813 }